package features.advance.leetcode.array.easy;


import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Queue;

/**
 * @author LIN
 * @date 2021-12-02 19:27
 *
 *  506. 相对名次
 *
 *  难度：简单
 *
 * 给你一个长度为 n 的整数数组 score ，其中 score[i] 是第 i 位运动员在比赛中的得分。所有得分都 互不相同 。
 *
 * 运动员将根据得分 决定名次 ，其中名次第 1 的运动员得分最高，名次第 2 的运动员得分第 2 高，依此类推。运动员的名次决定了他们的获奖情况：
 *
 * 名次第 1 的运动员获金牌 "Gold Medal" 。
 * 名次第 2 的运动员获银牌 "Silver Medal" 。
 * 名次第 3 的运动员获铜牌 "Bronze Medal" 。
 * 从名次第 4 到第 n 的运动员，只能获得他们的名次编号（即，名次第 x 的运动员获得编号 "x"）。
 * 使用长度为 n 的数组 answer 返回获奖，其中 answer[i] 是第 i 位运动员的获奖情况。
 *
 *
 *
 * 示例 1：
 *
 * 输入：score = [5,4,3,2,1]
 * 输出：["Gold Medal","Silver Medal","Bronze Medal","4","5"]
 * 解释：名次为 [1st, 2nd, 3rd, 4th, 5th] 。
 * 示例 2：
 *
 * 输入：score = [10,3,8,9,4]
 * 输出：["Gold Medal","5","Bronze Medal","Silver Medal","4"]
 * 解释：名次为 [1st, 5th, 3rd, 2nd, 4th] 。
 *
 *
 * 提示：
 *
 * n == score.length
 * 1 <= n <= 104
 * 0 <= score[i] <= 106
 * score 中的所有值 互不相同
 *
 */
public class Solution506 {

    public static void main(String[] args) {
        Solution solution = new Solution() {
            @Override
            public String[] findRelativeRanks(int[] score) {
                int n = score.length;
                String[] desc = {"Gold Medal", "Silver Medal", "Bronze Medal"};
                int[][] arr = new int[n][2];

                for (int i = 0; i < n; ++i) {
                    arr[i][0] = score[i];
                    arr[i][1] = i;
                }
                Arrays.sort(arr, (a, b) -> b[0] - a[0]);
                String[] ans = new String[n];
                for (int i = 0; i < n; ++i) {
                    if (i >= 3) {
                        ans[arr[i][1]] = Integer.toString(i + 1);
                    } else {
                        ans[arr[i][1]] = desc[i];
                    }
                }
                return ans;
            }
        };

        solution = new Solution(){
            @Override
            public String[] findRelativeRanks(int[] nums) {
                int n = nums.length;
                String[] result = new String[n];
                int max = 0;
                // 找出找出最高的成绩
                for (int num : nums) {
                    if (max < num) {
                        max = num;
                    }
                }
                // 下标为成绩，值为成绩在 nums 数组的下标
                int[] array = new int[max + 1];
                for (int i = 0; i < n; i++) {
                    array[nums[i]] = i + 1;
                }
                // 记录当前成绩的排名
                int count = 1;
                for (int i = array.length - 1; i >= 0; i--) {
                    if (array[i] != 0) {
                        // 根据排名进行赋值
                        switch (count) {
                            case 1:
                                result[array[i] - 1] = "Gold Medal";
                                break;
                            case 2:
                                result[array[i] - 1] = "Silver Medal";
                                break;
                            case 3:
                                result[array[i] - 1] = "Bronze Medal";
                                break;
                            default:
                                result[array[i] - 1] = String.valueOf(count);
                        }
                        count++;
                    }
                }
                return result;
            }
        };
        int[] score = {10,3,8,9,4};
        String[] relativeRanks = solution.findRelativeRanks(score);
        System.out.println(Arrays.toString(relativeRanks));
    }

    static class Solution {
        public String[] findRelativeRanks(int[] score) {
            class obj{
                int score;
                String reward;
                int seqno;

                int index;

                public int getIndex() {
                    return index;
                }

                public void setIndex(int index) {
                    this.index = index;
                }

                public int getScore() {
                    return score;
                }

                public void setScore(int score) {
                    this.score = score;
                }

                public String getReward() {
                    return reward;
                }

                public void setReward(String reward) {
                    this.reward = reward;
                }

                public int getSeqno() {
                    return seqno;
                }

                public void setSeqno(int seqno) {
                    this.seqno = seqno;
                }

                @Override
                public String toString() {
                    return "obj{" +
                            "score=" + score +
                            ", reward='" + reward + '\'' +
                            ", seqno=" + seqno +
                            ", index=" + index +
                            '}';
                }
            }
            Queue<obj> queue = new PriorityQueue<>((o1, o2) -> o2.getScore() - o1.getScore());
            for (int i = 0; i < score.length; i++) {
                int o = score[i];
                obj obj = new obj();
                obj.setScore(o);
                obj.setIndex(i);
                queue.add(obj);
            }
            int j = 0;
            String[] res = new String[score.length];
            while(!queue.isEmpty()){
                obj poll = queue.poll();
                poll.setSeqno(++j);
                String reward = getReward(poll.getSeqno());
                poll.setReward(reward);
                System.out.println(poll);
                res[poll.getIndex()] = reward;
            }
            return res;
        }

        private String getReward(int seqno) {
            switch (seqno){
                case 1:
                    return "Gold Medal";
                case 2:
                    return "Silver Medal";
                case 3:
                    return "Bronze Medal";
                default:
                    return String.valueOf(seqno);
            }
        }
    }
}
